// $ANTLR 3.4 C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g 2013-02-26 02:52:41

  package practica12;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class ExpresionesParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ASIGNA", "BLANCO", "COMPARADORES", "DIGITO", "DIV", "IDENT", "LETRA", "MAS", "MENOS", "MULT", "NUMERO", "PARENTESIS_A", "PARENTESIS_C", "PUNTO_COMA", "LISTA_INST"
    };

    public static final int EOF=-1;
    public static final int ASIGNA=4;
    public static final int BLANCO=5;
    public static final int COMPARADORES=6;
    public static final int DIGITO=7;
    public static final int DIV=8;
    public static final int IDENT=9;
    public static final int LETRA=10;
    public static final int MAS=11;
    public static final int MENOS=12;
    public static final int MULT=13;
    public static final int NUMERO=14;
    public static final int PARENTESIS_A=15;
    public static final int PARENTESIS_C=16;
    public static final int PUNTO_COMA=17;
    public static final int LISTA_INST=18;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public ExpresionesParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public ExpresionesParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return ExpresionesParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g"; }



    //    List<CommonTree> lista = new ArrayList<CommonTree>();
    //    Hashtable variables = new Hashtable();
        
        private ArrayList<RecognitionException> errors = new ArrayList<RecognitionException>();
        public ArrayList<RecognitionException> getErrors() {
           return errors;
        }
        @Override
        public void reportError (RecognitionException e) {
           String msg = getErrorMessage(e, getTokenNames());
           System.err.println(msg);
           errors.add(e);
        }


    public static class instrucciones_return extends ParserRuleReturnScope {
        MyTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "instrucciones"
    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:1: instrucciones : ( expresion PUNTO_COMA )* -> ^( LISTA_INST ( expresion )* ) ;
    public final ExpresionesParser.instrucciones_return instrucciones() throws RecognitionException {
        ExpresionesParser.instrucciones_return retval = new ExpresionesParser.instrucciones_return();
        retval.start = input.LT(1);


        MyTree root_0 = null;

        Token PUNTO_COMA2=null;
        ExpresionesParser.expresion_return expresion1 =null;


        MyTree PUNTO_COMA2_tree=null;
        RewriteRuleTokenStream stream_PUNTO_COMA=new RewriteRuleTokenStream(adaptor,"token PUNTO_COMA");
        RewriteRuleSubtreeStream stream_expresion=new RewriteRuleSubtreeStream(adaptor,"rule expresion");
        try {
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:14: ( ( expresion PUNTO_COMA )* -> ^( LISTA_INST ( expresion )* ) )
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:16: ( expresion PUNTO_COMA )*
            {
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:16: ( expresion PUNTO_COMA )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==IDENT||LA1_0==MENOS||(LA1_0 >= NUMERO && LA1_0 <= PARENTESIS_A)) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:17: expresion PUNTO_COMA
            	    {
            	    pushFollow(FOLLOW_expresion_in_instrucciones83);
            	    expresion1=expresion();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_expresion.add(expresion1.getTree());

            	    PUNTO_COMA2=(Token)match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_instrucciones85); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_PUNTO_COMA.add(PUNTO_COMA2);


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            // AST REWRITE
            // elements: expresion
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MyTree)adaptor.nil();
            // 36:40: -> ^( LISTA_INST ( expresion )* )
            {
                // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:43: ^( LISTA_INST ( expresion )* )
                {
                MyTree root_1 = (MyTree)adaptor.nil();
                root_1 = (MyTree)adaptor.becomeRoot(
                (MyTree)adaptor.create(LISTA_INST, "LISTA_INST")
                , root_1);

                // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:36:56: ( expresion )*
                while ( stream_expresion.hasNext() ) {
                    adaptor.addChild(root_1, stream_expresion.nextTree());

                }
                stream_expresion.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MyTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MyTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "instrucciones"


    public static class expresion_return extends ParserRuleReturnScope {
        MyTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expresion"
    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:1: expresion : exp_mult ( ( MAS ^| MENOS ^) exp_mult )* ;
    public final ExpresionesParser.expresion_return expresion() throws RecognitionException {
        ExpresionesParser.expresion_return retval = new ExpresionesParser.expresion_return();
        retval.start = input.LT(1);


        MyTree root_0 = null;

        Token MAS4=null;
        Token MENOS5=null;
        ExpresionesParser.exp_mult_return exp_mult3 =null;

        ExpresionesParser.exp_mult_return exp_mult6 =null;


        MyTree MAS4_tree=null;
        MyTree MENOS5_tree=null;

        try {
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:10: ( exp_mult ( ( MAS ^| MENOS ^) exp_mult )* )
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:12: exp_mult ( ( MAS ^| MENOS ^) exp_mult )*
            {
            root_0 = (MyTree)adaptor.nil();


            pushFollow(FOLLOW_exp_mult_in_expresion109);
            exp_mult3=exp_mult();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult3.getTree());

            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:21: ( ( MAS ^| MENOS ^) exp_mult )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0 >= MAS && LA3_0 <= MENOS)) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:22: ( MAS ^| MENOS ^) exp_mult
            	    {
            	    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:22: ( MAS ^| MENOS ^)
            	    int alt2=2;
            	    int LA2_0 = input.LA(1);

            	    if ( (LA2_0==MAS) ) {
            	        alt2=1;
            	    }
            	    else if ( (LA2_0==MENOS) ) {
            	        alt2=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 2, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt2) {
            	        case 1 :
            	            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:23: MAS ^
            	            {
            	            MAS4=(Token)match(input,MAS,FOLLOW_MAS_in_expresion113); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MAS4_tree = 
            	            (MyTree)adaptor.create(MAS4)
            	            ;
            	            root_0 = (MyTree)adaptor.becomeRoot(MAS4_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:42:28: MENOS ^
            	            {
            	            MENOS5=(Token)match(input,MENOS,FOLLOW_MENOS_in_expresion116); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MENOS5_tree = 
            	            (MyTree)adaptor.create(MENOS5)
            	            ;
            	            root_0 = (MyTree)adaptor.becomeRoot(MENOS5_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_mult_in_expresion120);
            	    exp_mult6=exp_mult();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult6.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MyTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MyTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expresion"


    public static class exp_mult_return extends ParserRuleReturnScope {
        MyTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_mult"
    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:1: exp_mult : exp_base ( ( MULT ^| DIV ^) exp_base )* ;
    public final ExpresionesParser.exp_mult_return exp_mult() throws RecognitionException {
        ExpresionesParser.exp_mult_return retval = new ExpresionesParser.exp_mult_return();
        retval.start = input.LT(1);


        MyTree root_0 = null;

        Token MULT8=null;
        Token DIV9=null;
        ExpresionesParser.exp_base_return exp_base7 =null;

        ExpresionesParser.exp_base_return exp_base10 =null;


        MyTree MULT8_tree=null;
        MyTree DIV9_tree=null;

        try {
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:10: ( exp_base ( ( MULT ^| DIV ^) exp_base )* )
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:12: exp_base ( ( MULT ^| DIV ^) exp_base )*
            {
            root_0 = (MyTree)adaptor.nil();


            pushFollow(FOLLOW_exp_base_in_exp_mult130);
            exp_base7=exp_base();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base7.getTree());

            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:21: ( ( MULT ^| DIV ^) exp_base )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==DIV||LA5_0==MULT) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:22: ( MULT ^| DIV ^) exp_base
            	    {
            	    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:22: ( MULT ^| DIV ^)
            	    int alt4=2;
            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0==MULT) ) {
            	        alt4=1;
            	    }
            	    else if ( (LA4_0==DIV) ) {
            	        alt4=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 4, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt4) {
            	        case 1 :
            	            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:23: MULT ^
            	            {
            	            MULT8=(Token)match(input,MULT,FOLLOW_MULT_in_exp_mult134); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MULT8_tree = 
            	            (MyTree)adaptor.create(MULT8)
            	            ;
            	            root_0 = (MyTree)adaptor.becomeRoot(MULT8_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:44:29: DIV ^
            	            {
            	            DIV9=(Token)match(input,DIV,FOLLOW_DIV_in_exp_mult137); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            DIV9_tree = 
            	            (MyTree)adaptor.create(DIV9)
            	            ;
            	            root_0 = (MyTree)adaptor.becomeRoot(DIV9_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_base_in_exp_mult141);
            	    exp_base10=exp_base();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base10.getTree());

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MyTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MyTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_mult"


    public static class exp_base_return extends ParserRuleReturnScope {
        MyTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_base"
    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:1: exp_base : ( MENOS ^)? ( NUMERO | IDENT | PARENTESIS_A ! expresion PARENTESIS_C !) ;
    public final ExpresionesParser.exp_base_return exp_base() throws RecognitionException {
        ExpresionesParser.exp_base_return retval = new ExpresionesParser.exp_base_return();
        retval.start = input.LT(1);


        MyTree root_0 = null;

        Token MENOS11=null;
        Token NUMERO12=null;
        Token IDENT13=null;
        Token PARENTESIS_A14=null;
        Token PARENTESIS_C16=null;
        ExpresionesParser.expresion_return expresion15 =null;


        MyTree MENOS11_tree=null;
        MyTree NUMERO12_tree=null;
        MyTree IDENT13_tree=null;
        MyTree PARENTESIS_A14_tree=null;
        MyTree PARENTESIS_C16_tree=null;

        try {
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:10: ( ( MENOS ^)? ( NUMERO | IDENT | PARENTESIS_A ! expresion PARENTESIS_C !) )
            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:12: ( MENOS ^)? ( NUMERO | IDENT | PARENTESIS_A ! expresion PARENTESIS_C !)
            {
            root_0 = (MyTree)adaptor.nil();


            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:12: ( MENOS ^)?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==MENOS) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:13: MENOS ^
                    {
                    MENOS11=(Token)match(input,MENOS,FOLLOW_MENOS_in_exp_base153); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    MENOS11_tree = 
                    (MyTree)adaptor.create(MENOS11)
                    ;
                    root_0 = (MyTree)adaptor.becomeRoot(MENOS11_tree, root_0);
                    }

                    }
                    break;

            }


            // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:22: ( NUMERO | IDENT | PARENTESIS_A ! expresion PARENTESIS_C !)
            int alt7=3;
            switch ( input.LA(1) ) {
            case NUMERO:
                {
                alt7=1;
                }
                break;
            case IDENT:
                {
                alt7=2;
                }
                break;
            case PARENTESIS_A:
                {
                alt7=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:23: NUMERO
                    {
                    NUMERO12=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_exp_base159); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    NUMERO12_tree = 
                    (MyTree)adaptor.create(NUMERO12)
                    ;
                    adaptor.addChild(root_0, NUMERO12_tree);
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:32: IDENT
                    {
                    IDENT13=(Token)match(input,IDENT,FOLLOW_IDENT_in_exp_base163); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENT13_tree = 
                    (MyTree)adaptor.create(IDENT13)
                    ;
                    adaptor.addChild(root_0, IDENT13_tree);
                    }

                    }
                    break;
                case 3 :
                    // C:\\Users\\usuario\\workspace\\Practica12-PL\\src\\practica12\\ExpresionesParser.g:46:40: PARENTESIS_A ! expresion PARENTESIS_C !
                    {
                    PARENTESIS_A14=(Token)match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_exp_base167); if (state.failed) return retval;

                    pushFollow(FOLLOW_expresion_in_exp_base170);
                    expresion15=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion15.getTree());

                    PARENTESIS_C16=(Token)match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_exp_base172); if (state.failed) return retval;

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MyTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MyTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_base"

    // Delegated rules


 

    public static final BitSet FOLLOW_expresion_in_instrucciones83 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_instrucciones85 = new BitSet(new long[]{0x000000000000D202L});
    public static final BitSet FOLLOW_exp_mult_in_expresion109 = new BitSet(new long[]{0x0000000000001802L});
    public static final BitSet FOLLOW_MAS_in_expresion113 = new BitSet(new long[]{0x000000000000D200L});
    public static final BitSet FOLLOW_MENOS_in_expresion116 = new BitSet(new long[]{0x000000000000D200L});
    public static final BitSet FOLLOW_exp_mult_in_expresion120 = new BitSet(new long[]{0x0000000000001802L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult130 = new BitSet(new long[]{0x0000000000002102L});
    public static final BitSet FOLLOW_MULT_in_exp_mult134 = new BitSet(new long[]{0x000000000000D200L});
    public static final BitSet FOLLOW_DIV_in_exp_mult137 = new BitSet(new long[]{0x000000000000D200L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult141 = new BitSet(new long[]{0x0000000000002102L});
    public static final BitSet FOLLOW_MENOS_in_exp_base153 = new BitSet(new long[]{0x000000000000C200L});
    public static final BitSet FOLLOW_NUMERO_in_exp_base159 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_exp_base163 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_exp_base167 = new BitSet(new long[]{0x000000000000D200L});
    public static final BitSet FOLLOW_expresion_in_exp_base170 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_exp_base172 = new BitSet(new long[]{0x0000000000000002L});

}